qaGobiApiUim.h

Go to the documentation of this file.

#ifndef __GOBI_API_UIM_H__
#define __GOBI_API_UIM_H__

#ifdef __cplusplus
extern "C" {
#endif

#define MAX_DESCRIPTION_LENGTH 255
#define MAX_CONTENT_LENGTH     1024
#define MAX_NO_OF_APPLICATIONS 10
#define MAX_NO_OF_SLOTS        5
#define MAX_PUK_LENGTH         8
#define MAX_PATH_LENGTH        255
#define MAX_ICCID_LENGTH       255
#define MAX_SLOTS_STATUS       255
#define MAX_ATR_LENGTH         255
#define MAX_PHY_SLOTS_INFO     255

#define MAX_ACTIVE_PERS_FEATURES   12

ULONG SLQSUIMReset();

typedef struct
{
    BYTE slot;
} UIMPowerDownReq;

ULONG SLQSUIMPowerDown ( UIMPowerDownReq *pUIMPowerDownReq );

typedef struct {
    WORD  fileID;
    BYTE  pathLen;
    WORD  path[MAX_PATH_LENGTH];
} fileInfo;

typedef struct
{
    /* Every response message must have a results structure */
    struct qmTlvResult results;
    BYTE     stage;
    BYTE     mode;
    BYTE     sessionType;
    BYTE     aidLength;
    BYTE     aid[MAX_DESCRIPTION_LENGTH];
    WORD     numOfFiles;
    fileInfo arrfileInfo[MAX_DESCRIPTION_LENGTH];
} UIMRefreshEvent;

typedef struct
{
    BYTE appType;
    BYTE appState;
    BYTE persoState;
    BYTE persoFeature;
    BYTE persoRetries;
    BYTE persoUnblockRetries;
    BYTE aidLength;
    BYTE aidVal[MAX_DESCRIPTION_LENGTH];
    BYTE univPin;
    BYTE pin1State;
    BYTE pin1Retries;
    BYTE puk1Retries;
    BYTE pin2State;
    BYTE pin2Retries;
    BYTE puk2Retries;
} appStatus;

typedef struct
{
    BYTE      cardState;
    BYTE      upinState;
    BYTE      upinRetries;
    BYTE      upukRetries;
    BYTE      errorState;
    BYTE      numApp;
    appStatus AppStatus[MAX_NO_OF_APPLICATIONS];
} slotInfo;

typedef struct
{
    WORD     indexGwPri;
    WORD     index1xPri;
    WORD     indexGwSec;
    WORD     index1xSec;
    BYTE     numSlot;
    slotInfo SlotInfo[MAX_NO_OF_SLOTS];
} cardStatus;

typedef struct
{
    BYTE hotSwapLength;
    BYTE hotSwap[MAX_DESCRIPTION_LENGTH];
} hotSwapStatus;

typedef struct
{
    BYTE validCardLength;
    BYTE validCard[MAX_DESCRIPTION_LENGTH];
} validCardStatus;

typedef struct
{
    BYTE simBusyLength;
    BYTE simBusy[MAX_DESCRIPTION_LENGTH];
} simBusyStatus;

typedef struct
{
    cardStatus    *pCardStatus;
    hotSwapStatus *pHotSwapStatus;
} UIMGetCardStatusResp;

typedef struct
{
    cardStatus    *pCardStatus;
    hotSwapStatus *pHotSwapStatus;
    validCardStatus *pValidCardStatus;
    simBusyStatus *pSimBusyStatus;
} UIMGetCardStatusRespV2;


ULONG SLQSUIMGetCardStatus ( UIMGetCardStatusResp *pUIMGetCardStatusResp );


ULONG SLQSUIMGetCardStatusV2 ( UIMGetCardStatusRespV2 *pUIMGetCardStatusResp );

typedef struct
{
    BYTE sw1;
    BYTE sw2;
} cardResult;

typedef struct
{
    BYTE   sessionType;
    BYTE   aidLength;
    BYTE   aid[MAX_DESCRIPTION_LENGTH];
} UIMSessionInformation ;

typedef struct
{
    BYTE pinID;
    BYTE pinOperation;
    BYTE pinLength;
    BYTE pinValue[MAX_DESCRIPTION_LENGTH];
} setPINProtection;

typedef struct
{
    UIMSessionInformation sessionInfo;
    setPINProtection      pinProtection;
    BYTE                  *pKeyReferenceID;
    ULONG                 *pIndicationToken;
} UIMSetPinProtectionReq ;

typedef struct
{
    BYTE verifyLeft;
    BYTE unblockLeft;
} remainingRetries;

typedef struct
{
    BYTE pin1Len;
    BYTE pin1Val[MAX_DESCRIPTION_LENGTH];
} encryptedPIN1;

typedef struct
{
    remainingRetries *pRemainingRetries;
    encryptedPIN1    *pEncryptedPIN1;
    ULONG            *pIndicationToken;
} UIMPinResp;

typedef struct
{
    remainingRetries *pRemainingRetries;
    encryptedPIN1    *pEncryptedPIN1;
    ULONG            *pIndicationToken;
    cardResult       *pCardResult;
} UIMPinRespV2;

ULONG SLQSUIMSetPinProtection (
                UIMSetPinProtectionReq *pUIMSetPinProtectionReq,
                UIMPinResp             *pUIMSetPinProtectionResp );

typedef struct{
    BYTE pinID;
    BYTE pinLen;
    BYTE pinVal[MAX_DESCRIPTION_LENGTH];
} verifyUIMPIN;

typedef struct
{
    UIMSessionInformation sessionInfo;
    verifyUIMPIN          verifyPIN;
    encryptedPIN1         *pEncryptedPIN1;
    BYTE                  *pKeyReferenceID;
    ULONG                 *pIndicationToken;
} UIMVerifyPinReq;

ULONG SLQSUIMVerifyPin ( UIMVerifyPinReq *pUIMVerifyPinReq,
                         UIMPinResp      *pUIMVerifyPinResp );

typedef struct{
    BYTE pinID;
    BYTE oldPINLen;
    BYTE oldPINVal[MAX_DESCRIPTION_LENGTH];
    BYTE pinLen;
    BYTE pinVal[MAX_DESCRIPTION_LENGTH];
} changeUIMPIN;

typedef struct
{
    UIMSessionInformation sessionInfo;
    changeUIMPIN          changePIN;
    BYTE                  *pKeyReferenceID;
    ULONG                 *pIndicationToken;
} UIMChangePinReq;

ULONG SLQSUIMChangePin ( UIMChangePinReq *pUIMChangePinReq,
                         UIMPinResp      *pUIMChangePinResp );

typedef struct{
    BYTE pinID;
    BYTE pukLen;
    BYTE pukVal[MAX_DESCRIPTION_LENGTH];
    BYTE newPINLen;
    BYTE newPINVal[MAX_DESCRIPTION_LENGTH];
} unblockUIMPIN;

typedef struct
{
    UIMSessionInformation sessionInfo;
    unblockUIMPIN         unblockPIN;
    BYTE                  *pKeyReferenceID;
    ULONG                 *pIndicationToken;
} UIMUnblockPinReq;

ULONG SLQSUIMUnblockPin ( UIMUnblockPinReq *pUIMUnblockPinReq,
                          UIMPinResp       *pUIMUnblockPinResp );

ULONG SLQSUIMUnblockPinV2 ( UIMUnblockPinReq *pUIMUnblockPinReq,
                            UIMPinRespV2       *pUIMUnblockPinResp );

typedef struct
{
    ULONG eventMask;
} UIMEventRegisterReqResp;

ULONG SLQSUIMEventRegister (
    UIMEventRegisterReqResp *pUIMEventRegisterReqResp );

typedef struct
{
    UIMSessionInformation sessionInfo;
    BYTE                  OKtoRefresh;
} UIMRefreshOKReq;

ULONG SLQSUIMRefreshOK (
    UIMRefreshOKReq *pUIMRefreshOKReq );

typedef struct
{
    BYTE     registerFlag;
    BYTE     voteForInit;
    WORD     numFiles;
    fileInfo arrfileInfo[MAX_DESCRIPTION_LENGTH];
} registerRefresh;

typedef struct
{
    UIMSessionInformation sessionInfo;
    registerRefresh       regRefresh;
} UIMRefreshRegisterReq;

ULONG SLQSUIMRefreshRegister(
    UIMRefreshRegisterReq *pUIMRefreshRegisterReq );

typedef struct
{
    UIMSessionInformation  sessionInfo;
    BYTE                   refreshComplete;
} UIMRefreshCompleteReq;


ULONG SLQSUIMRefreshComplete (
    UIMRefreshCompleteReq *pUIMRefreshCompleteReq );

typedef struct
{
    UIMRefreshEvent *pRefreshEvent;
} UIMRefreshGetLastEventResp;

typedef struct
{
    UIMSessionInformation sessionInfo;
} UIMRefreshGetLastEventReq;

ULONG SLQSUIMRefreshGetLastEvent (
    UIMRefreshGetLastEventReq  *pUIMRefreshGetLastEventReq,
    UIMRefreshGetLastEventResp *pUIMRefreshGetLastEventResp );

typedef struct
{
    UIMSessionInformation sessionInfo;
    fileInfo              fileIndex;
    ULONG                 *pIndicationToken;
} UIMGetFileAttributesReq;

typedef struct
{
    WORD fileSize;
    WORD fileID;
    BYTE fileType;
    WORD recordSize;
    WORD recordCount;
    BYTE secRead;
    WORD secReadMask;
    BYTE secWrite;
    WORD secWriteMask;
    BYTE secIncrease;
    WORD secIncreaseMask;
    BYTE secDeactivate;
    WORD secDeactivateMask;
    BYTE secActivate;
    WORD secActivateMask;
    WORD rawLen;
    BYTE rawValue[MAX_DESCRIPTION_LENGTH];
} fileAttributes;

typedef struct
{
    cardResult     *pCardResult;
    fileAttributes *pFileAttributes;
    ULONG          *pIndicationToken;
} UIMGetFileAttributesResp;

ULONG SLQSUIMGetFileAttributes (
                      UIMGetFileAttributesReq  *pUIMGetFileAttributesReq,
                      UIMGetFileAttributesResp *pUIMGetFileAttributesResp );

typedef struct{
    BYTE  feature;
    BYTE  operation;
    BYTE  ckLen;
    BYTE  ckVal[MAX_DESCRIPTION_LENGTH];
} depersonalizationInformation;

typedef struct
{
    depersonalizationInformation depersonilisationInfo;
} UIMDepersonalizationReq;

typedef struct
{
    remainingRetries *pRemainingRetries;
} UIMDepersonalizationResp;

ULONG SLQSUIMDepersonalization (
                      UIMDepersonalizationReq  *pUIMDepersonilizationReq,
                      UIMDepersonalizationResp *pUIMDepersonilizationResp );

typedef struct
{
    BYTE context;
    WORD dataLen;
    BYTE data[MAX_CONTENT_LENGTH];
} authenticationData;

typedef struct
{
    UIMSessionInformation sessionInfo;
    authenticationData    authData;
    ULONG                 *pIndicationToken;
} UIMAuthenticateReq;

typedef struct
{
    WORD contentLen;
    BYTE content[MAX_CONTENT_LENGTH];
} authenticateResult;

typedef struct
{
    cardResult         *pCardResult;
    authenticateResult *pAuthenticateResult;
    ULONG              *pIndicationToken;
} UIMAuthenticateResp;

ULONG SLQSUIMAuthenticate ( UIMAuthenticateReq  *pUIMAuthenticateReq,
                            UIMAuthenticateResp *pUIMAuthenticateResp);
typedef struct
{
    WORD contentLen;
    BYTE content[MAX_DESCRIPTION_LENGTH+1];
} readResult;

typedef struct
{
    WORD offset;
    WORD length;
} readTransparentInfo;

typedef struct
{
    UIMSessionInformation sessionInfo;
    fileInfo              fileIndex;
    readTransparentInfo   readTransparent;
    ULONG                 *pIndicationToken;
    BYTE                  *pEncryptData;
} UIMReadTransparentReq;

typedef struct
{
    cardResult   *pCardResult;
    readResult   *pReadResult;
    ULONG        *pIndicationToken;
    BYTE         *pEncryptedData;
} UIMReadTransparentResp;

ULONG SLQSUIMReadTransparent (
        UIMReadTransparentReq  *pUIMReadTransparentReq,
        UIMReadTransparentResp *pUIMReadTransparentResp );

typedef struct
{
    BYTE slot;
    BYTE *pIgnoreHotSwapSwitch;
} UIMPowerUpReq;

ULONG SLQSUIMPowerUp ( UIMPowerUpReq *pUIMPowerUpReq );

typedef struct
{
    ULONG   uPhyCardStatus;
    ULONG   uPhySlotStatus;
    BYTE    bLogicalSlot;
    BYTE    bICCIDLength;
    BYTE    bICCID[MAX_ICCID_LENGTH];
}UIMSlotStatus;

typedef struct
{
    UIMSlotStatus uimSlotStatus[MAX_SLOTS_STATUS];
}UIMSlotsStatus;


typedef struct
{
    ULONG   cardProtocol;
    BYTE    numApp;
    BYTE    atrValueLen;
    BYTE    atrValue[MAX_ATR_LENGTH];
    BYTE    iseUICC;
}UIMSlotInfo;

typedef struct
{
    UIMSlotInfo uimSlotInfo[MAX_PHY_SLOTS_INFO];
}UIMSlotsInfo;

typedef struct
{
    BYTE            *pNumberOfPhySlot;
    UIMSlotsStatus *pUimSlotsStatus;
} UIMGetSlotsStatusResp;

typedef struct
{
    BYTE            NumberOfPhySlot;
    UIMSlotStatus   uimSlotStatus[MAX_SLOTS_STATUS];
    BYTE            TlvPresent;
} GetSlotsStatusTlv;

typedef struct
{
    BYTE            NumberOfPhySlotInfo;
    UIMSlotInfo     uimSlotInfo[MAX_PHY_SLOTS_INFO];
    BYTE            TlvPresent;
} GetSlotsInfoTlv;

typedef struct
{
    GetSlotsStatusTlv       *pGetSlotsStatusTlv;
    GetSlotsInfoTlv         *pGetSlotsInfoTlv;
} UIMGetSlotsStatusRespV2;

ULONG SLQSUIMGetSlotsStatus(UIMGetSlotsStatusResp *pResp);

ULONG SLQSUIMGetSlotsStatusV2(UIMGetSlotsStatusRespV2 *pResp);

typedef struct
{
    BYTE bLogicalSlot;
    ULONG ulPhysicalSlot;
}UIMSwitchSlotReq;

ULONG SLQSUIMSwitchSlot(UIMSwitchSlotReq *pReq );

typedef struct
{
    BYTE numFeatures;
    BYTE feature[MAX_ACTIVE_PERS_FEATURES];
    BYTE verifyLeft[MAX_ACTIVE_PERS_FEATURES];
    BYTE unblockLeft[MAX_ACTIVE_PERS_FEATURES];
} personalizationStatus;

typedef struct
{
    ULONG                 *pConfigurationMask;
} UIMGetConfigurationReq;

typedef struct
{
    BYTE                   *pAutoSelection;
    personalizationStatus  *pPersonalizationStatus;
    BYTE                   *pHaltSubscription;
} UIMGetConfigurationResp;

ULONG SLQSUIMGetConfiguration (
        UIMGetConfigurationReq  *pUIMGetConfigurationReq,
        UIMGetConfigurationResp *pUIMGetConfigurationResp );

typedef struct
{
    UIMSessionInformation sessionInfo;
    BYTE                  *pFDNStatus;
} UIMSetServiceStatusReq;

ULONG SLQSUIMSetServiceStatus ( UIMSetServiceStatusReq *pUIMSetServiceStatusReq );

typedef struct
{
    UIMSessionInformation sessionInfo;
    ULONG                 capMask;
} UIMGetServiceStatusReq;

typedef struct
{
    BYTE  FDNStatus;
    BYTE  TlvPresent;
}UIMGetFDNStatus;

typedef struct
{
    BYTE  hiddenKey;
    BYTE  TlvPresent;
}UIMGetHiddenKeyStatus;

typedef struct
{
    BYTE  index;
    BYTE  TlvPresent;
}UIMGetIndex;

typedef struct
{
    UIMGetFDNStatus       *pFDNStatus;
    UIMGetHiddenKeyStatus *pHiddenKeyStatus;
    UIMGetIndex           *pIndex;
} UIMGetServiceStatusResp;

ULONG SLQSUIMGetServiceStatus ( UIMGetServiceStatusReq  *pUIMGetServiceStatusReq,
                                UIMGetServiceStatusResp *pUIMGetServiceStatusResp );

typedef struct
{
    WORD record;
    WORD length;
} readRecordInfo;

typedef struct
{
    UIMSessionInformation sessionInfo;
    fileInfo              fileIndex;
    readRecordInfo        readRecord;
    WORD                  *pLastRecord;
    ULONG                 *pIndicationToken;
} UIMReadRecordReq;

typedef struct
{
    BYTE sw1;
    BYTE sw2;
    BYTE TlvPresent;
} cardResultInfo;

typedef struct
{
    WORD contentLen;
    BYTE content[MAX_DESCRIPTION_LENGTH];
    BYTE  TlvPresent;
} readResultInfo;

typedef struct
{
    WORD additionalRecordLen;
    BYTE additionalRecord[MAX_DESCRIPTION_LENGTH];
    BYTE  TlvPresent;
} additionalReadResult;

typedef struct
{
    ULONG       token;
    BYTE        TlvPresent;
}indToken;

typedef struct
{
    cardResultInfo        *pCardResult;
    readResultInfo        *pReadResult;
    additionalReadResult  *pAdditionalReadResult;
    indToken              *pIndicationToken;
} UIMReadRecordResp;

ULONG SLQSUIMReadRecord ( UIMReadRecordReq  *pUIMReadRecordReq,
                          UIMReadRecordResp *pUIMReadRecordResp );

typedef struct
{
    WORD record;
    WORD dataLen;
    BYTE data[MAX_DESCRIPTION_LENGTH];
} writeRecordInfo;

typedef struct
{
    UIMSessionInformation sessionInfo;
    fileInfo              fileIndex;
    writeRecordInfo       writeRecord;
    ULONG                *pIndicationToken;
} UIMWriteRecordReq;

typedef struct
{
    cardResultInfo   *pCardResult;
    indToken         *pIndicationToken;
} UIMWriteRecordResp;

ULONG SLQSUIMWriteRecord (
                      UIMWriteRecordReq  *pUIMWriteRecordReq,
                      UIMWriteRecordResp *pUIMWriteRecordResp );

typedef struct
{
    WORD offset;
    WORD dataLen;
    BYTE data[MAX_CONTENT_LENGTH];
} writeTransparentInfo;

typedef struct
{
    UIMSessionInformation  sessionInfo;
    fileInfo               fileIndex;
    writeTransparentInfo   writeTransparent;
    ULONG                  *pIndicationToken;
} UIMWriteTransparentReq;

typedef struct
{
    cardResultInfo     *pCardResult;
    indToken           *pIndicationToken;
} UIMWriteTransparentResp;

ULONG SLQSUIMWriteTransparent ( UIMWriteTransparentReq  *pUIMWriteTransparentReq,
                                UIMWriteTransparentResp *pUIMWriteTransparentResp);

typedef struct
{
    BYTE eidLen;
    BYTE eidVal[MAX_DESCRIPTION_LENGTH];
    BYTE TlvPresent;
} eidInfo;

typedef struct
{
    BYTE    *pUimSlot;
} UIMGetEidReq;

typedef struct
{
    eidInfo *pEidInfo;
} UIMGetEidResp;

ULONG SLQSUIMGetEID (UIMGetEidReq *pSlotID,
                    UIMGetEidResp *pResp );

typedef struct
{
    WORD dataLen;
    BYTE data[MAX_DESCRIPTION_LENGTH];
} UIMProfileCode;


typedef struct
{
    BYTE                  slot;
    UIMProfileCode        profileActInfo;
    UIMProfileCode        *pProfileConfInfo;
    BYTE                  *pUserConsent;
} UIMAddProfileReq;

ULONG SLQSUIMAddProfile ( UIMAddProfileReq *pUIMAddProfileReq );

typedef struct
{
    BYTE                  slot;
    ULONG                 profileId;
} UIMDeleteProfileReq;

ULONG SLQSUIMDeleteProfile ( UIMDeleteProfileReq *pUIMDeleteProfileReq );

typedef struct
{
    BYTE dataLen;
    BYTE data[MAX_DESCRIPTION_LENGTH];
} UIMNickName;

typedef struct
{
    BYTE                  slot;
    ULONG                 profileId;
    UIMNickName           *pNickName;
} UIMUpdateProfileReq;

ULONG SLQSUIMUpdateProfile ( UIMUpdateProfileReq *pUIMUpdateProfileReq );

typedef struct
{
    BYTE                  slotNo;
} UIMGetSIMProfileReq;

typedef struct
{
    BYTE        profileInfoLen;
    ULONG       profileId[MAX_DESCRIPTION_LENGTH];
    ULONG       profileType[MAX_DESCRIPTION_LENGTH];
    BYTE        TlvPresent;
} getSimProfileInfo;

typedef struct
{
    ULONG       profileId;
    ULONG       profileType;
    BYTE        TlvPresent;
}activeProfileInfo;

typedef struct
{
    getSimProfileInfo     *pProfileInfo;
    activeProfileInfo     *pActiveProfileInfo;
} UIMGetSIMProfileResp;

ULONG SLQSUIMGetSIMProfile ( UIMGetSIMProfileReq  *pUIMGetSIMProfileReq,
                             UIMGetSIMProfileResp *pUIMGetSIMProfileResp );

typedef struct
{
    BYTE           setSlot;
    ULONG          profileId;
    BYTE           *pProfileStatus;
} UIMSetSIMProfileReq;

ULONG SLQSUIMSetSIMProfile ( UIMSetSIMProfileReq *pUIMSetSIMProfileReq );

typedef struct
{
    BYTE            profileICCIDLen;
    BYTE            profileICCID[MAX_DESCRIPTION_LENGTH];
    BYTE            TlvPresent;
} profileICCIDTlv;

typedef struct
{
    ULONG           profileState;
    BYTE            TlvPresent;
} profileStateTlv;

typedef struct
{
    BYTE            profileNicknameLen;
    BYTE            profileNickname[MAX_DESCRIPTION_LENGTH];
    BYTE            TlvPresent;
} profileNicknameTlv;

typedef struct
{
    BYTE            profileSPNLen;
    BYTE            profileSPN[MAX_DESCRIPTION_LENGTH];
    BYTE            TlvPresent;
} profileSPNTlv;

typedef struct
{
    BYTE            profileNameLen;
    BYTE            profileName[MAX_DESCRIPTION_LENGTH];
    BYTE            TlvPresent;
} profileNameTlv;

typedef struct
{
    ULONG           profileIconType;
    BYTE            TlvPresent;
} profileIconTypeTlv;

typedef struct
{
    WORD            profileIconDataLen;
    BYTE            profileIconData[MAX_DESCRIPTION_LENGTH];
    BYTE            TlvPresent;
} profileIconTlv;

typedef struct
{
    ULONG           profileClass;
    BYTE            TlvPresent;
} profileClassTlv;

typedef struct
{
    ULONGLONG       profilePolicyRules;
    BYTE            TlvPresent;
} profilePolicyRulesTlv;

typedef struct
{
    BYTE                  slotNo;
    ULONG                 profileId;
} UIMGetProfileInfoReq;

typedef struct
{
    profileICCIDTlv       *pProfileICCID;
    profileStateTlv       *pProfileState;
    profileNicknameTlv    *pProfileNickname;
    profileSPNTlv         *pProfileSPN;
    profileNameTlv        *pProfileName;
    profileIconTypeTlv    *pProfileIconType;
    profileIconTlv        *pProfileIcon;
    profileClassTlv       *pProfileClass;
    profilePolicyRulesTlv *pProfilePolicyRules;
} UIMGetProfileInfoResp;

ULONG SLQSUIMGetProfileInfo ( UIMGetProfileInfoReq  *pUIMGetProfileInfoReq,
                              UIMGetProfileInfoResp *pUIMGetProfileInfoResp );

typedef struct
{
    BYTE           uimSlot;
    ULONGLONG      *pResetOption;
} UIMeUICCMemResetReq;

ULONG SLQSUIMeUICCMemReset ( UIMeUICCMemResetReq *pUIMeUICCMemResetReq );

#ifdef __cplusplus
} /* extern "C" { */
#endif

#endif /* __GOBI_API_UIM_H__ */